home *** CD-ROM | disk | FTP | other *** search
/ Micromanía: 150 Juegos 2010 / 150Juegos_16.iso / Shareware / Shape Smash / shape-smash.swf / scripts / Box2D / Dynamics / Joints / _af232.as next >
Encoding:
Text File  |  2010-05-14  |  17.2 KB  |  477 lines
  1. package Box2D.Dynamics.Joints
  2. {
  3.    import Box2D.Common.Math._oh327;
  4.    import Box2D.Common.Math._ui293;
  5.    import Box2D.Common.Math.b2Vec2;
  6.    import Box2D.Common._kc225;
  7.    import Box2D.Dynamics._th791;
  8.    import Box2D.Dynamics._ut97;
  9.    
  10.    public class _af232 extends _yw701
  11.    {
  12.       public static var tImpulse:b2Vec2 = new b2Vec2();
  13.       
  14.       public var m_limitForce:Number;
  15.       
  16.       public var m_pivotMass:_oh327;
  17.       
  18.       public var m_motorForce:Number;
  19.       
  20.       public var m_enableLimit:Boolean;
  21.       
  22.       public var m_limitState:int;
  23.       
  24.       public var m_motorMass:Number;
  25.       
  26.       public var m_localAnchor2:b2Vec2;
  27.       
  28.       private var K3:_oh327;
  29.       
  30.       public var m_localAnchor1:b2Vec2;
  31.       
  32.       private var K1:_oh327;
  33.       
  34.       public var m_pivotForce:b2Vec2;
  35.       
  36.       private var K2:_oh327;
  37.       
  38.       public var m_motorSpeed:Number;
  39.       
  40.       public var m_enableMotor:Boolean;
  41.       
  42.       public var m_referenceAngle:Number;
  43.       
  44.       public var m_limitPositionImpulse:Number;
  45.       
  46.       public var m_lowerAngle:Number;
  47.       
  48.       public var m_upperAngle:Number;
  49.       
  50.       public var m_maxMotorTorque:Number;
  51.       
  52.       private var K:_oh327;
  53.       
  54.       public function _af232(param1:_fa684)
  55.       {
  56.          K = new _oh327();
  57.          K1 = new _oh327();
  58.          K2 = new _oh327();
  59.          K3 = new _oh327();
  60.          m_localAnchor1 = new b2Vec2();
  61.          m_localAnchor2 = new b2Vec2();
  62.          m_pivotForce = new b2Vec2();
  63.          m_pivotMass = new _oh327();
  64.          super(param1);
  65.          m_localAnchor1._kh737(param1.localAnchor1);
  66.          m_localAnchor2._kh737(param1.localAnchor2);
  67.          m_referenceAngle = param1.referenceAngle;
  68.          m_pivotForce._br741(0,0);
  69.          m_motorForce = 0;
  70.          m_limitForce = 0;
  71.          m_limitPositionImpulse = 0;
  72.          m_lowerAngle = param1.lowerAngle;
  73.          m_upperAngle = param1.upperAngle;
  74.          m_maxMotorTorque = param1.maxMotorTorque;
  75.          m_motorSpeed = param1.motorSpeed;
  76.          m_enableLimit = param1.enableLimit;
  77.          m_enableMotor = param1.enableMotor;
  78.       }
  79.       
  80.       public function _nx630() : Number
  81.       {
  82.          return m_motorSpeed;
  83.       }
  84.       
  85.       public function _hi565() : Number
  86.       {
  87.          return m_upperAngle;
  88.       }
  89.       
  90.       override public function _md397(param1:_ut97) : void
  91.       {
  92.          var _loc2_:_th791 = null;
  93.          var _loc3_:_th791 = null;
  94.          var _loc4_:_oh327 = null;
  95.          var _loc5_:Number = NaN;
  96.          var _loc6_:Number = NaN;
  97.          var _loc7_:Number = NaN;
  98.          var _loc8_:Number = NaN;
  99.          var _loc9_:Number = NaN;
  100.          var _loc10_:Number = NaN;
  101.          var _loc11_:Number = NaN;
  102.          var _loc12_:Number = NaN;
  103.          var _loc13_:Number = NaN;
  104.          var _loc14_:Number = NaN;
  105.          var _loc15_:Number = NaN;
  106.          var _loc16_:Number = NaN;
  107.          var _loc17_:Number = NaN;
  108.          var _loc18_:Number = NaN;
  109.          var _loc19_:Number = NaN;
  110.          var _loc20_:Number = NaN;
  111.          var _loc21_:Number = NaN;
  112.          _loc2_ = m_body1;
  113.          _loc3_ = m_body2;
  114.          _loc4_ = _loc2_.m_xf.R;
  115.          _loc6_ = m_localAnchor1.x - _loc2_.m_sweep.localCenter.x;
  116.          _loc7_ = m_localAnchor1.y - _loc2_.m_sweep.localCenter.y;
  117.          _loc5_ = _loc4_.col1.x * _loc6_ + _loc4_.col2.x * _loc7_;
  118.          _loc7_ = _loc4_.col1.y * _loc6_ + _loc4_.col2.y * _loc7_;
  119.          _loc6_ = _loc5_;
  120.          _loc4_ = _loc3_.m_xf.R;
  121.          _loc8_ = m_localAnchor2.x - _loc3_.m_sweep.localCenter.x;
  122.          _loc9_ = m_localAnchor2.y - _loc3_.m_sweep.localCenter.y;
  123.          _loc5_ = _loc4_.col1.x * _loc8_ + _loc4_.col2.x * _loc9_;
  124.          _loc9_ = _loc4_.col1.y * _loc8_ + _loc4_.col2.y * _loc9_;
  125.          _loc8_ = _loc5_;
  126.          _loc11_ = _loc3_.m_linearVelocity.x + -_loc3_.m_angularVelocity * _loc9_ - _loc2_.m_linearVelocity.x - -_loc2_.m_angularVelocity * _loc7_;
  127.          _loc12_ = _loc3_.m_linearVelocity.y + _loc3_.m_angularVelocity * _loc8_ - _loc2_.m_linearVelocity.y - _loc2_.m_angularVelocity * _loc6_;
  128.          _loc13_ = -param1.inv_dt * (m_pivotMass.col1.x * _loc11_ + m_pivotMass.col2.x * _loc12_);
  129.          _loc14_ = -param1.inv_dt * (m_pivotMass.col1.y * _loc11_ + m_pivotMass.col2.y * _loc12_);
  130.          m_pivotForce.x += _loc13_;
  131.          m_pivotForce.y += _loc14_;
  132.          _loc15_ = param1.dt * _loc13_;
  133.          _loc16_ = param1.dt * _loc14_;
  134.          _loc2_.m_linearVelocity.x -= _loc2_.m_invMass * _loc15_;
  135.          _loc2_.m_linearVelocity.y -= _loc2_.m_invMass * _loc16_;
  136.          _loc2_.m_angularVelocity -= _loc2_.m_invI * (_loc6_ * _loc16_ - _loc7_ * _loc15_);
  137.          _loc3_.m_linearVelocity.x += _loc3_.m_invMass * _loc15_;
  138.          _loc3_.m_linearVelocity.y += _loc3_.m_invMass * _loc16_;
  139.          _loc3_.m_angularVelocity += _loc3_.m_invI * (_loc8_ * _loc16_ - _loc9_ * _loc15_);
  140.          if(m_enableMotor && m_limitState != e_equalLimits)
  141.          {
  142.             _loc17_ = _loc3_.m_angularVelocity - _loc2_.m_angularVelocity - m_motorSpeed;
  143.             _loc18_ = -param1.inv_dt * m_motorMass * _loc17_;
  144.             _loc19_ = m_motorForce;
  145.             m_motorForce = _ui293._mx500(m_motorForce + _loc18_,-m_maxMotorTorque,m_maxMotorTorque);
  146.             _loc18_ = m_motorForce - _loc19_;
  147.             _loc2_.m_angularVelocity -= _loc2_.m_invI * param1.dt * _loc18_;
  148.             _loc3_.m_angularVelocity += _loc3_.m_invI * param1.dt * _loc18_;
  149.          }
  150.          if(m_enableLimit && m_limitState != e_inactiveLimit)
  151.          {
  152.             _loc20_ = _loc3_.m_angularVelocity - _loc2_.m_angularVelocity;
  153.             _loc21_ = -param1.inv_dt * m_motorMass * _loc20_;
  154.             if(m_limitState == e_equalLimits)
  155.             {
  156.                m_limitForce += _loc21_;
  157.             }
  158.             else if(m_limitState == e_atLowerLimit)
  159.             {
  160.                _loc10_ = m_limitForce;
  161.                m_limitForce = _ui293._bk45(m_limitForce + _loc21_,0);
  162.                _loc21_ = m_limitForce - _loc10_;
  163.             }
  164.             else if(m_limitState == e_atUpperLimit)
  165.             {
  166.                _loc10_ = m_limitForce;
  167.                m_limitForce = _ui293._ct557(m_limitForce + _loc21_,0);
  168.                _loc21_ = m_limitForce - _loc10_;
  169.             }
  170.             _loc2_.m_angularVelocity -= _loc2_.m_invI * param1.dt * _loc21_;
  171.             _loc3_.m_angularVelocity += _loc3_.m_invI * param1.dt * _loc21_;
  172.          }
  173.       }
  174.       
  175.       public function _rh631() : Number
  176.       {
  177.          return m_body2.m_angularVelocity - m_body1.m_angularVelocity;
  178.       }
  179.       
  180.       override public function _xt20() : Number
  181.       {
  182.          return m_limitForce;
  183.       }
  184.       
  185.       override public function _mf779(param1:_ut97) : void
  186.       {
  187.          var _loc2_:_th791 = null;
  188.          var _loc3_:_th791 = null;
  189.          var _loc4_:_oh327 = null;
  190.          var _loc5_:Number = NaN;
  191.          var _loc6_:Number = NaN;
  192.          var _loc7_:Number = NaN;
  193.          var _loc8_:Number = NaN;
  194.          var _loc9_:Number = NaN;
  195.          var _loc10_:Number = NaN;
  196.          var _loc11_:Number = NaN;
  197.          var _loc12_:Number = NaN;
  198.          var _loc13_:Number = NaN;
  199.          var _loc14_:Number = NaN;
  200.          _loc2_ = m_body1;
  201.          _loc3_ = m_body2;
  202.          _loc4_ = _loc2_.m_xf.R;
  203.          _loc6_ = m_localAnchor1.x - _loc2_.m_sweep.localCenter.x;
  204.          _loc7_ = m_localAnchor1.y - _loc2_.m_sweep.localCenter.y;
  205.          _loc5_ = _loc4_.col1.x * _loc6_ + _loc4_.col2.x * _loc7_;
  206.          _loc7_ = _loc4_.col1.y * _loc6_ + _loc4_.col2.y * _loc7_;
  207.          _loc6_ = _loc5_;
  208.          _loc4_ = _loc3_.m_xf.R;
  209.          _loc8_ = m_localAnchor2.x - _loc3_.m_sweep.localCenter.x;
  210.          _loc9_ = m_localAnchor2.y - _loc3_.m_sweep.localCenter.y;
  211.          _loc5_ = _loc4_.col1.x * _loc8_ + _loc4_.col2.x * _loc9_;
  212.          _loc9_ = _loc4_.col1.y * _loc8_ + _loc4_.col2.y * _loc9_;
  213.          _loc8_ = _loc5_;
  214.          _loc10_ = _loc2_.m_invMass;
  215.          _loc11_ = _loc3_.m_invMass;
  216.          _loc12_ = _loc2_.m_invI;
  217.          _loc13_ = _loc3_.m_invI;
  218.          K1.col1.x = _loc10_ + _loc11_;
  219.          K1.col2.x = 0;
  220.          K1.col1.y = 0;
  221.          K1.col2.y = _loc10_ + _loc11_;
  222.          K2.col1.x = _loc12_ * _loc7_ * _loc7_;
  223.          K2.col2.x = -_loc12_ * _loc6_ * _loc7_;
  224.          K2.col1.y = -_loc12_ * _loc6_ * _loc7_;
  225.          K2.col2.y = _loc12_ * _loc6_ * _loc6_;
  226.          K3.col1.x = _loc13_ * _loc9_ * _loc9_;
  227.          K3.col2.x = -_loc13_ * _loc8_ * _loc9_;
  228.          K3.col1.y = -_loc13_ * _loc8_ * _loc9_;
  229.          K3.col2.y = _loc13_ * _loc8_ * _loc8_;
  230.          K._kp63(K1);
  231.          K._lk586(K2);
  232.          K._lk586(K3);
  233.          K._ma772(m_pivotMass);
  234.          m_motorMass = 1 / (_loc12_ + _loc13_);
  235.          if(m_enableMotor == false)
  236.          {
  237.             m_motorForce = 0;
  238.          }
  239.          if(m_enableLimit)
  240.          {
  241.             _loc14_ = _loc3_.m_sweep.a - _loc2_.m_sweep.a - m_referenceAngle;
  242.             if(_ui293._if129(m_upperAngle - m_lowerAngle) < 2 * _kc225.b2_angularSlop)
  243.             {
  244.                m_limitState = e_equalLimits;
  245.             }
  246.             else if(_loc14_ <= m_lowerAngle)
  247.             {
  248.                if(m_limitState != e_atLowerLimit)
  249.                {
  250.                   m_limitForce = 0;
  251.                }
  252.                m_limitState = e_atLowerLimit;
  253.             }
  254.             else if(_loc14_ >= m_upperAngle)
  255.             {
  256.                if(m_limitState != e_atUpperLimit)
  257.                {
  258.                   m_limitForce = 0;
  259.                }
  260.                m_limitState = e_atUpperLimit;
  261.             }
  262.             else
  263.             {
  264.                m_limitState = e_inactiveLimit;
  265.                m_limitForce = 0;
  266.             }
  267.          }
  268.          else
  269.          {
  270.             m_limitForce = 0;
  271.          }
  272.          if(param1.warmStarting)
  273.          {
  274.             _loc2_.m_linearVelocity.x -= param1.dt * _loc10_ * m_pivotForce.x;
  275.             _loc2_.m_linearVelocity.y -= param1.dt * _loc10_ * m_pivotForce.y;
  276.             _loc2_.m_angularVelocity -= param1.dt * _loc12_ * (_loc6_ * m_pivotForce.y - _loc7_ * m_pivotForce.x + m_motorForce + m_limitForce);
  277.             _loc3_.m_linearVelocity.x += param1.dt * _loc11_ * m_pivotForce.x;
  278.             _loc3_.m_linearVelocity.y += param1.dt * _loc11_ * m_pivotForce.y;
  279.             _loc3_.m_angularVelocity += param1.dt * _loc13_ * (_loc8_ * m_pivotForce.y - _loc9_ * m_pivotForce.x + m_motorForce + m_limitForce);
  280.          }
  281.          else
  282.          {
  283.             m_pivotForce._he34();
  284.             m_motorForce = 0;
  285.             m_limitForce = 0;
  286.          }
  287.          m_limitPositionImpulse = 0;
  288.       }
  289.       
  290.       public function _am566(param1:Boolean) : void
  291.       {
  292.          m_enableMotor = param1;
  293.       }
  294.       
  295.       public function _iq252(param1:Number) : void
  296.       {
  297.          m_motorSpeed = param1;
  298.       }
  299.       
  300.       public function _tp162() : Number
  301.       {
  302.          return m_body2.m_sweep.a - m_body1.m_sweep.a - m_referenceAngle;
  303.       }
  304.       
  305.       public function _pd489() : Boolean
  306.       {
  307.          return m_enableLimit;
  308.       }
  309.       
  310.       public function _ao440(param1:Number, param2:Number) : void
  311.       {
  312.          m_lowerAngle = param1;
  313.          m_upperAngle = param2;
  314.       }
  315.       
  316.       override public function _va771() : b2Vec2
  317.       {
  318.          return m_body2._pj447(m_localAnchor2);
  319.       }
  320.       
  321.       public function _iv315() : Number
  322.       {
  323.          return m_lowerAngle;
  324.       }
  325.       
  326.       override public function _ms688() : b2Vec2
  327.       {
  328.          return m_body1._pj447(m_localAnchor1);
  329.       }
  330.       
  331.       public function _kp205() : Number
  332.       {
  333.          return m_motorForce;
  334.       }
  335.       
  336.       public function _mt254() : Boolean
  337.       {
  338.          return m_enableMotor;
  339.       }
  340.       
  341.       public function _gw134(param1:Boolean) : void
  342.       {
  343.          m_enableLimit = param1;
  344.       }
  345.       
  346.       override public function _mx220() : b2Vec2
  347.       {
  348.          return m_pivotForce;
  349.       }
  350.       
  351.       public function _ba672(param1:Number) : void
  352.       {
  353.          m_maxMotorTorque = param1;
  354.       }
  355.       
  356.       override public function _sl623() : Boolean
  357.       {
  358.          var _loc1_:Number = NaN;
  359.          var _loc2_:Number = NaN;
  360.          var _loc3_:_th791 = null;
  361.          var _loc4_:_th791 = null;
  362.          var _loc5_:Number = NaN;
  363.          var _loc6_:_oh327 = null;
  364.          var _loc7_:Number = NaN;
  365.          var _loc8_:Number = NaN;
  366.          var _loc9_:Number = NaN;
  367.          var _loc10_:Number = NaN;
  368.          var _loc11_:Number = NaN;
  369.          var _loc12_:Number = NaN;
  370.          var _loc13_:Number = NaN;
  371.          var _loc14_:Number = NaN;
  372.          var _loc15_:Number = NaN;
  373.          var _loc16_:Number = NaN;
  374.          var _loc17_:Number = NaN;
  375.          var _loc18_:Number = NaN;
  376.          var _loc19_:Number = NaN;
  377.          var _loc20_:Number = NaN;
  378.          var _loc21_:Number = NaN;
  379.          var _loc22_:Number = NaN;
  380.          var _loc23_:Number = NaN;
  381.          var _loc24_:Number = NaN;
  382.          var _loc25_:Number = NaN;
  383.          var _loc26_:Number = NaN;
  384.          _loc3_ = m_body1;
  385.          _loc4_ = m_body2;
  386.          _loc5_ = 0;
  387.          _loc6_ = _loc3_.m_xf.R;
  388.          _loc7_ = m_localAnchor1.x - _loc3_.m_sweep.localCenter.x;
  389.          _loc8_ = m_localAnchor1.y - _loc3_.m_sweep.localCenter.y;
  390.          _loc9_ = _loc6_.col1.x * _loc7_ + _loc6_.col2.x * _loc8_;
  391.          _loc8_ = _loc6_.col1.y * _loc7_ + _loc6_.col2.y * _loc8_;
  392.          _loc7_ = _loc9_;
  393.          _loc6_ = _loc4_.m_xf.R;
  394.          _loc10_ = m_localAnchor2.x - _loc4_.m_sweep.localCenter.x;
  395.          _loc11_ = m_localAnchor2.y - _loc4_.m_sweep.localCenter.y;
  396.          _loc9_ = _loc6_.col1.x * _loc10_ + _loc6_.col2.x * _loc11_;
  397.          _loc11_ = _loc6_.col1.y * _loc10_ + _loc6_.col2.y * _loc11_;
  398.          _loc10_ = _loc9_;
  399.          _loc12_ = _loc3_.m_sweep.c.x + _loc7_;
  400.          _loc13_ = _loc3_.m_sweep.c.y + _loc8_;
  401.          _loc14_ = _loc4_.m_sweep.c.x + _loc10_;
  402.          _loc15_ = _loc4_.m_sweep.c.y + _loc11_;
  403.          _loc16_ = _loc14_ - _loc12_;
  404.          _loc17_ = _loc15_ - _loc13_;
  405.          _loc5_ = Math.sqrt(_loc16_ * _loc16_ + _loc17_ * _loc17_);
  406.          _loc18_ = _loc3_.m_invMass;
  407.          _loc19_ = _loc4_.m_invMass;
  408.          _loc20_ = _loc3_.m_invI;
  409.          _loc21_ = _loc4_.m_invI;
  410.          K1.col1.x = _loc18_ + _loc19_;
  411.          K1.col2.x = 0;
  412.          K1.col1.y = 0;
  413.          K1.col2.y = _loc18_ + _loc19_;
  414.          K2.col1.x = _loc20_ * _loc8_ * _loc8_;
  415.          K2.col2.x = -_loc20_ * _loc7_ * _loc8_;
  416.          K2.col1.y = -_loc20_ * _loc7_ * _loc8_;
  417.          K2.col2.y = _loc20_ * _loc7_ * _loc7_;
  418.          K3.col1.x = _loc21_ * _loc11_ * _loc11_;
  419.          K3.col2.x = -_loc21_ * _loc10_ * _loc11_;
  420.          K3.col1.y = -_loc21_ * _loc10_ * _loc11_;
  421.          K3.col2.y = _loc21_ * _loc10_ * _loc10_;
  422.          K._kp63(K1);
  423.          K._lk586(K2);
  424.          K._lk586(K3);
  425.          K._eq278(tImpulse,-_loc16_,-_loc17_);
  426.          _loc22_ = tImpulse.x;
  427.          _loc23_ = tImpulse.y;
  428.          _loc3_.m_sweep.c.x -= _loc3_.m_invMass * _loc22_;
  429.          _loc3_.m_sweep.c.y -= _loc3_.m_invMass * _loc23_;
  430.          _loc3_.m_sweep.a -= _loc3_.m_invI * (_loc7_ * _loc23_ - _loc8_ * _loc22_);
  431.          _loc4_.m_sweep.c.x += _loc4_.m_invMass * _loc22_;
  432.          _loc4_.m_sweep.c.y += _loc4_.m_invMass * _loc23_;
  433.          _loc4_.m_sweep.a += _loc4_.m_invI * (_loc10_ * _loc23_ - _loc11_ * _loc22_);
  434.          _loc3_._tp414();
  435.          _loc4_._tp414();
  436.          _loc24_ = 0;
  437.          if(m_enableLimit && m_limitState != e_inactiveLimit)
  438.          {
  439.             _loc25_ = _loc4_.m_sweep.a - _loc3_.m_sweep.a - m_referenceAngle;
  440.             _loc26_ = 0;
  441.             if(m_limitState == e_equalLimits)
  442.             {
  443.                _loc2_ = _ui293._mx500(_loc25_,-_kc225.b2_maxAngularCorrection,_kc225.b2_maxAngularCorrection);
  444.                _loc26_ = -m_motorMass * _loc2_;
  445.                _loc24_ = _ui293._if129(_loc2_);
  446.             }
  447.             else if(m_limitState == e_atLowerLimit)
  448.             {
  449.                _loc2_ = _loc25_ - m_lowerAngle;
  450.                _loc24_ = _ui293._bk45(0,-_loc2_);
  451.                _loc2_ = _ui293._mx500(_loc2_ + _kc225.b2_angularSlop,-_kc225.b2_maxAngularCorrection,0);
  452.                _loc26_ = -m_motorMass * _loc2_;
  453.                _loc1_ = m_limitPositionImpulse;
  454.                m_limitPositionImpulse = _ui293._bk45(m_limitPositionImpulse + _loc26_,0);
  455.                _loc26_ = m_limitPositionImpulse - _loc1_;
  456.             }
  457.             else if(m_limitState == e_atUpperLimit)
  458.             {
  459.                _loc2_ = _loc25_ - m_upperAngle;
  460.                _loc24_ = _ui293._bk45(0,_loc2_);
  461.                _loc2_ = _ui293._mx500(_loc2_ - _kc225.b2_angularSlop,0,_kc225.b2_maxAngularCorrection);
  462.                _loc26_ = -m_motorMass * _loc2_;
  463.                _loc1_ = m_limitPositionImpulse;
  464.                m_limitPositionImpulse = _ui293._ct557(m_limitPositionImpulse + _loc26_,0);
  465.                _loc26_ = m_limitPositionImpulse - _loc1_;
  466.             }
  467.             _loc3_.m_sweep.a -= _loc3_.m_invI * _loc26_;
  468.             _loc4_.m_sweep.a += _loc4_.m_invI * _loc26_;
  469.             _loc3_._tp414();
  470.             _loc4_._tp414();
  471.          }
  472.          return _loc5_ <= _kc225.b2_linearSlop && _loc24_ <= _kc225.b2_angularSlop;
  473.       }
  474.    }
  475. }
  476.  
  477.